Deutsche Edition 1/Deutsche Edition 1.iso/amok/081-090/amok85/streams/streams2.mod

Text File | 1993-11-04 | 6KB | 229 lines

(*------------------------------------------

  :Program.     Streams
  :Author.      Dieter Bogdoll [db]
  :Address.     SMail: Gudrunstr. 7, D-8000 München 19
  :Address.     EMail: [e-mail]
  :Address.     EMail: 2:246/221.3@fidonet
  :Address.     EMail: [e-mail]
  :Version.     V1.0a
  :Date.        20-Feb-1993
  :Copyright.   Public Domain
  :Language.    Oberon
  :Translator.  Amiga Oberon 3.00d
  :Support.     Objektorientierte Programmierung in Oberon-2
  :Imports.     Format [db] : aehnlich Format wie in io.mod
  :Contents.    abstrakte Datenmodel Streams
  :Contents.    Zeichenstroeme fuer Zeichenein/ausgabe
  :Contents.    sei es per Console oder Files
  :Bugs.        nicht ausfuehrlich getestet
  :History.     V0.0   [db] 15-Feb-1993 : Erstellt
  :History.     V0.1   [db] 19-Feb-1993 : sollte fuer alle Oberon-Compiler
  :History.                               geeignet sein
  :History.     V0.2   [db] 19-Feb-1993 : speziell an den Amiga angepasst
  :History.                               zb. Format, Printf
  :History.     V1.0a  [db] 20-Feb-1993 : Gebrauchsfertig

--------------------------------------------*)
MODULE Streams;

IMPORT e:=Exec, y:=SYSTEM, f:Format;

CONST
  eof = 1CX;

TYPE
  Stream* = POINTER TO StreamDesc;
  StreamDesc* = RECORD END;

  PROCEDURE (s: Stream) Open* (name: ARRAY OF CHAR; new: BOOLEAN): BOOLEAN;
    (* $CopyArrays- *)
    BEGIN HALT(99)
  END Open;

  PROCEDURE (s: Stream) Close* (): BOOLEAN;
    BEGIN HALT(99)
  END Close;

  PROCEDURE (s: Stream) Write* (ch: CHAR);
    BEGIN HALT(99)
  END Write;

  PROCEDURE (s: Stream) WriteLn*;
    BEGIN
      s.Write("\n");
  END WriteLn;

  PROCEDURE (s: Stream) WriteString* (a: ARRAY OF CHAR);
    (* $CopyArrays- *)
    VAR i : INTEGER;
    BEGIN
      i:=0;
      WHILE a[i]#0X DO s.Write(a[i]); INC(i); END
  END WriteString;

  PROCEDURE (s: Stream) WriteLongInt* (value: LONGINT; width: INTEGER);
    VAR helpstr : ARRAY 40 OF CHAR;
    BEGIN
      f.Format1(helpstr, "%%%ldld", width);
      f.Format1(helpstr, helpstr, value);
      s.WriteString(helpstr);
  END WriteLongInt;

  PROCEDURE (s: Stream) WriteInt* (value, width: INTEGER);
    BEGIN
      s.WriteLongInt(value, width)
  END WriteInt;

  PROCEDURE (s: Stream) WriteShortInt* (value: SHORTINT; width: INTEGER);
    BEGIN
      s.WriteLongInt(value, width)
  END WriteShortInt;

  PROCEDURE (s: Stream) WriteHex* (value: LONGINT; width: INTEGER);
    VAR helpstr : ARRAY 40 OF CHAR;
    BEGIN
      IF width>=0 THEN
          f.Format1(helpstr, "%%0%ldlx", width);
        ELSE
          width := -width;
          f.Format1(helpstr, "%%-%ldlx", width);
      END;
      f.Format1(helpstr, helpstr, value);
      s.WriteString(helpstr);
  END WriteHex;

  PROCEDURE (s: Stream) Printf0*(a: ARRAY OF CHAR);
    (* $CopyArrays- *)
    VAR helpstr : ARRAY 256 OF CHAR;
    BEGIN
      f.Format0(helpstr, a);
      s.WriteString(helpstr)
  END Printf0;

  PROCEDURE (s: Stream) Printf1*(a: ARRAY OF CHAR; data1: LONGINT);
    (* $CopyArrays- *)
    VAR helpstr : ARRAY 256 OF CHAR;
    BEGIN
      f.Format1(helpstr, a, data1);
      s.WriteString(helpstr)
  END Printf1;

  PROCEDURE (s: Stream) Printf2*(a: ARRAY OF CHAR; data1, data2: LONGINT);
    (* $CopyArrays- *)
    VAR helpstr : ARRAY 256 OF CHAR;
    BEGIN
      f.Format2(helpstr, a, data1, data2);
      s.WriteString(helpstr)
  END Printf2;

  PROCEDURE (s: Stream) Printf3*(a: ARRAY OF CHAR; data1, data2, data3: LONGINT);
    (* $CopyArrays- *)
    VAR helpstr : ARRAY 256 OF CHAR;
    BEGIN
      f.Format3(helpstr, a, data1, data2, data3);
      s.WriteString(helpstr)
  END Printf3;

  PROCEDURE (s: Stream) Printf4*(a: ARRAY OF CHAR;
                                 data1, data2, data3, data4: LONGINT);
    (* $CopyArrays- *)
    VAR helpstr : ARRAY 256 OF CHAR;
    BEGIN
      f.Format4(helpstr, a, data1, data2, data3, data4);
      s.WriteString(helpstr)
  END Printf4;

  PROCEDURE (s: Stream) Read* (VAR ch: CHAR);
    BEGIN HALT (99)
  END Read;

  PROCEDURE (s: Stream) ReadString* (VAR a: ARRAY OF CHAR);
    (* $CopyArrays- *)
    VAR i : INTEGER;
    BEGIN
      i := 0;
      REPEAT
        s.Read(a[i]);
        CASE a[i] OF
          "\n",eof,0X:      a[i] := 0X; RETURN
        ELSE
        END;
        INC(i);
      UNTIL i=LEN(a);
  END ReadString;

  PROCEDURE (s: Stream) ReadLongInt* (VAR value: LONGINT): BOOLEAN;
  VAR
    ch: CHAR;
    d: LONGINT;
    neg: BOOLEAN;
    str: ARRAY 40 OF CHAR;
    i: INTEGER;
  BEGIN
    value := 0; i := 0;
    s.ReadString(str);
    neg := FALSE;
    IF str[0]="-" THEN neg := TRUE; i := 1 END;
    LOOP
      ch := str[i];
      CASE ch OF
      0X: IF neg THEN value := -value END; RETURN TRUE |
      "0".."9":
        d := ORD(ch)-ORD("0");
        IF (MAX(LONGINT)-d) DIV 10 >= value THEN value := 10*value+d ELSE EXIT END |
      ELSE EXIT END;
      INC(i);
    END;
    RETURN FALSE;
  END ReadLongInt;

  PROCEDURE (s: Stream) ReadInt*(VAR value: INTEGER): BOOLEAN;
  VAR
    l: LONGINT;
  BEGIN
    IF s.ReadLongInt(l) & (l>=MIN(INTEGER)) & (l<=MAX(INTEGER)) THEN
      value := SHORT(l);
      RETURN TRUE;
    END;
    RETURN FALSE;
  END ReadInt;


  PROCEDURE (s: Stream) ReadShortInt*(VAR value: SHORTINT): BOOLEAN;
  VAR
    l: LONGINT;
  BEGIN
    IF s.ReadLongInt(l) & (l>=MIN(SHORTINT)) & (l<=MAX(SHORTINT)) THEN
      value := SHORT(SHORT(l));
      RETURN TRUE;
    END;
    RETURN FALSE;
  END ReadShortInt;


  PROCEDURE (s: Stream) ReadHex*(VAR value: LONGINT): BOOLEAN;
  VAR
    ch: CHAR;
    d: LONGINT;
    str: ARRAY 40 OF CHAR;
    i: INTEGER;
  BEGIN
    value := 0; i := 0;
    s.ReadString(str);
    LOOP
      ch := CAP(str[i]);
      CASE ch OF
      0X:       RETURN TRUE |
      "0".."9": DEC(ch,ORD("0")) |
      "A".."F": DEC(ch,ORD("A")-10) |
      ELSE EXIT END;
      d := ORD(ch);
      IF (MAX(LONGINT)-d) DIV 16 >= value THEN value := 16*value+d ELSE EXIT END;
      INC(i);
    END;
    RETURN FALSE;
  END ReadHex;

END Streams.